package Logica;
import java.util.ArrayList;
    


public class Nodo {
    
    int operacionAplicada[];  
    /*Operacion aplicada contiene el indice de la ficha movida , el desplazamiento en x y el desplazamiento en y*/
    Nodo padre;
    int profundidad;
    String tipo;
    int posiciones[][]=new int[16][2];
    int color;
    String[]fichas={"p","P","p","P","p","P","p","P","b","B","h","H","q","Q","k","K"};
    String tablero[][]=new String [6][6];
   

    public Nodo(int posiciones[][], int[] operacionAplicada, Nodo padre,int color,int profundidad) {       
        this.posiciones=posiciones;
        this.operacionAplicada = operacionAplicada;
        this.padre = padre;
        this.color=color;
        this.profundidad=profundidad;      
    }
     public void GenerarTablero(int posiciones[][])
   {
       int posicion[];
       for (int i = 0; i < 6; i++) {
           for (int j = 0; j < 6; j++) {
               tablero[i][j]="0";               
           }           
       }
       for (int i = 0; i < 16; i++) {
           posicion=posiciones[i];
           tablero[posicion[0]][posicion[1]]=fichas[i];
       }
   }
     
     public String[][] getTablero(){
       return tablero;
   }
     
    public int CalcularHeuristica()
    {
        return 0;
    }
    
    
    public boolean Jaque(int color)
    {
        int rey[];
        if(color==0)rey=posiciones[14];
        else rey=posiciones[15];
        
        boolean jaque=false;
       int posicionEvaluar[]=new int [2];
       int incrementos[][]=new int[8][2];
       incrementos[0][0]=incrementos[1][0]=incrementos[7][0]=incrementos[1][1]=incrementos[2][1]=incrementos[3][1]=1;
       incrementos[2][0]=incrementos[6][0]=incrementos[0][1]=incrementos[4][1]=0;
       incrementos[3][0]=incrementos[4][0]=incrementos[5][0]=incrementos[5][1]=incrementos[6][1]=incrementos[7][1]=-1;
       while(!jaque)
       {
            for (int i = 1; i < 6; i++) {
                for (int j = 0; j < 8; j++) {
                    posicionEvaluar=new int[]{rey[0]+i*incrementos[j][0],rey[1]+i*incrementos[j][1]};
                    if(posicionEvaluar[0]>=0&&posicionEvaluar[0]<=6&&posicionEvaluar[1]>=0&&posicionEvaluar[1]<=6)
                    {
                        if(FichaContraria(posicionEvaluar,color))
                        {
                            String ficha=fichas[IndiceFicha(posicionEvaluar)];
                            if(ficha.equals("p"))
                            {
                                if((Math.abs(posicionEvaluar[1]-rey[1])==1)&&(posicionEvaluar[0]==rey[0]-1))jaque=true;
                            }
                            else if(ficha.equals("P"))
                            {
                                if((Math.abs(posicionEvaluar[1]-rey[1])==1)&&(posicionEvaluar[0]==rey[0]+1))jaque=true;
                            }
                            else if(ficha.equalsIgnoreCase("h"))
                            {
                                if(((Math.abs(posicionEvaluar[1]-rey[1])==2)&&(Math.abs(posicionEvaluar[0]-rey[0])==1))||((Math.abs(posicionEvaluar[1]-rey[1])==1)&&(Math.abs(posicionEvaluar[0]-rey[0])==2)))jaque=true;
                            }
                            else if(ficha.equalsIgnoreCase("b")||ficha.equalsIgnoreCase("q"))
                            {
                                if(posicionEvaluar[0]-rey[0]>0)
                                {
                                   if(posicionEvaluar[1]-rey[1]>0) 
                                   {
                                     int cont=1;
                                     while(rey[0]+cont<posicionEvaluar[0])
                                     {
                                         if(CasillaVacia(new int[]{rey[0]+cont,rey[1]+cont}))cont++;
                                         else break;
                                     }
                                     if(cont==(posicionEvaluar[0]-rey[0]-1))jaque=true;
                                   }
                                   else if(posicionEvaluar[1]-rey[1]<0){
                                       int cont=1;
                                     while(rey[0]+cont<posicionEvaluar[0])
                                     {
                                         if(CasillaVacia(new int[]{rey[0]+cont,rey[1]-cont}))cont++;
                                         else break;
                                     }
                                     if(cont==(posicionEvaluar[0]-rey[0]-1))jaque=true;
                                       
                                   }else if(ficha.equalsIgnoreCase("q")) 
                                   {
                                       int index=rey[0];
                                       while(index<posicionEvaluar[0])
                                       {
                                           if(CasillaVacia(new int[]{index,posicionEvaluar[1]}))index++;
                                           else break;
                                       }
                                       if(index==posicionEvaluar[0]-1)jaque=true;
                                   }
                                }else if(posicionEvaluar[0]-rey[0]<0){
                                    if(posicionEvaluar[1]-rey[1]>0) 
                                   {
                                     int cont=1;
                                     while(rey[0]+cont<posicionEvaluar[0])
                                     {
                                         if(CasillaVacia(new int[]{rey[0]+cont,rey[1]-cont}))cont++;
                                         else break;
                                     }
                                     if(cont==(rey[0]-posicionEvaluar[0]-1))jaque=true;
                                   }
                                   else if(posicionEvaluar[1]-rey[1]<0){
                                       int cont=1;
                                     while(rey[0]+cont<posicionEvaluar[0])
                                     {
                                         if(CasillaVacia(new int[]{rey[0]-cont,rey[1]-cont}))cont++;
                                         else break;
                                     }
                                     if(cont==(rey[0]-posicionEvaluar[0]-1))jaque=true;
                                       
                                   }else if(ficha.equalsIgnoreCase("q")) 
                                   {
                                       int index=rey[0];
                                       while(index>posicionEvaluar[0])
                                       {
                                           if(CasillaVacia(new int[]{index,posicionEvaluar[1]}))index--;
                                           else break;
                                       }
                                       if(index==posicionEvaluar[0]+1)jaque=true;
                                   }                                    
                                }else{
                                    if(ficha.equalsIgnoreCase("q"))
                                    {
                                        if(posicionEvaluar[1]-rey[1]>0)
                                        {
                                            int cont=rey[1]+1;
                                            while(cont<posicionEvaluar[1])
                                            {
                                                if(CasillaVacia(new int[]{posicionEvaluar[0],cont}))cont++;
                                                else break;
                                            }
                                            if(cont==(posicionEvaluar[1]-1))jaque=true;
                                        }else{
                                            int cont=rey[1]-1;
                                            while(cont>posicionEvaluar[1])
                                            {
                                                if(CasillaVacia(new int[]{posicionEvaluar[0],cont}))cont--;
                                                else break;
                                            }
                                            if(cont==(posicionEvaluar[1]+1))jaque=true;
                                            
                                        }
                                    }
                                }
                            }
                            else if(ficha.equalsIgnoreCase("k"))
                            {
                                if(Math.abs(posicionEvaluar[0]-rey[0])==1&&Math.abs(posicionEvaluar[1]-rey[1])==1)jaque=true;
                            }
                            
                        }
                    }

                }           
           }
       }
       return jaque;        
    }
    
    public ArrayList<Nodo> DeterminarPosiblesJugadas(int color)
    {
        ArrayList<Nodo> jugadas=new ArrayList();
        int inicio=color;
        for (int i = inicio; i < 16; i=i+2) {
            if(posiciones[i][0]!=-1)jugadas.addAll(Mover(posiciones[i],i,color));            
        }
        
        return jugadas;
    }
    
    boolean CasillaVacia(int posicion[])
    {
        boolean valido=true;
        int x=posicion[0],y=posicion[1];
        if((x<6)&&(x>=0)&&(x<6)&&(x>=0))
        {
            if(!tablero[x][y].equals("0"))valido=false;
            
        }else valido=false;
        
        return valido;        
    }
    
    int IndiceFicha(int posicion[])
    {
        int pos=-1,i=0;
        while(i<16)
        {
            if(posiciones[i]==posicion){
                pos=i;
                break;
            }else i++;
        }
        return pos;        
    }
    
    boolean FichaContraria(int posicion[],int color)
    {
      boolean contraria=false;
      int index=IndiceFicha(posicion);
      if(index>0)
      {
          if((index%2)==(color+1)%2)contraria=true;
      }
      return contraria;
    }
    
    public ArrayList<Nodo> Mover(int posicion[],int indiceFicha,int color)
    {
        int cambioPosiciones[][]=posiciones;
        int x=posicion[0],y=posicion[1];
        int index,cont;
        String ficha=fichas[indiceFicha];
        int incrementos[][]=new int[8][2];
        ArrayList<Nodo> jugadas=new ArrayList();
        Nodo actual;
        if(ficha.equals("p"))
        {
           if(x<5)
           {
               if(CasillaVacia(new int[]{x+1,y}))
               {
                   cambioPosiciones[indiceFicha]=new int[]{x+1,y};
                   actual=new Nodo(cambioPosiciones,new int[]{indiceFicha,x+1,y},this,(this.color+1)%2,this.profundidad+1);
                   if(!actual.Jaque(color))
                   {
                     jugadas.add(actual);
                    cambioPosiciones=posiciones;  
                   }                   
               }
               for(int i=y-1;i<=y+1;i=i+2)
               {
                   if(FichaContraria(new int[]{x+1,i},this.color))
                   {
                       cambioPosiciones[indiceFicha]=new int[]{x+1,i};
                       index=IndiceFicha(new int[]{x+1,i});
                       cambioPosiciones[index]=new int[]{-1,-1};
                       actual=new Nodo(cambioPosiciones,new int[]{indiceFicha,x+1,i},this,(this.color+1)%2,this.profundidad+1);
                       if(!actual.Jaque(color))
                       {
                         jugadas.add(actual);
                        cambioPosiciones=posiciones;  
                       }   
                   }
               }
           }
        }
        else if(ficha.equals("P"))
        {
            if(x>0)
           {
               if(CasillaVacia(new int[]{x-1,y}))
               {
                   cambioPosiciones[indiceFicha]=new int[]{x-1,y};
                   actual=new Nodo(cambioPosiciones,new int[]{indiceFicha,x-1,y},this,(this.color+1)%2,this.profundidad+1);
                       if(!actual.Jaque(color))
                       {
                         jugadas.add(actual);
                        cambioPosiciones=posiciones;  
                       }  
               }
               for(int i=y-1;i<=y+1;i=i+2)
               {
                   if(FichaContraria(new int[]{x-1,i},this.color))
                   {
                       cambioPosiciones[indiceFicha]=new int[]{x-1,i};
                       index=IndiceFicha(new int[]{x-1,i});
                       cambioPosiciones[index]=new int[]{-1,-1};
                       actual=new Nodo(cambioPosiciones,new int[]{indiceFicha,x-1,i},this,(this.color+1)%2,this.profundidad+1);
                       if(!actual.Jaque(color))
                       {
                         jugadas.add(actual);
                        cambioPosiciones=posiciones;  
                       }  
                   }
               }
           }
        }
        else if(ficha.equalsIgnoreCase("b"))
        {
            cont=1;
            
            for(int i=x-1;i>=0;i--)
            {
                if(CasillaVacia(new int[]{i,y-cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y-cont};
                   actual=new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y-cont},this,(this.color+1)%2,this.profundidad+1);
                       if(!actual.Jaque(color))
                       {
                         jugadas.add(actual);
                        cambioPosiciones=posiciones;  
                       } 
                }else if(FichaContraria(new int[]{i,y-cont},this.color))
                {
                    cambioPosiciones[indiceFicha]=new int[]{i,y-cont}; 
                       index=IndiceFicha(new int[]{i,y-cont});
                    cambioPosiciones[index]=new int[]{-1,-1};
                    actual=new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y-cont},this,(this.color+1)%2,this.profundidad+1);
                       if(!actual.Jaque(color))
                       {
                         jugadas.add(actual);
                        cambioPosiciones=posiciones;  
                       } 
                }
                
                else if(CasillaVacia(new int[]{i,y+cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y+cont}; 
                   actual=new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y+cont},this,(this.color+1)%2,this.profundidad+1);
                       if(!actual.Jaque(color))
                       {
                         jugadas.add(actual);
                        cambioPosiciones=posiciones;  
                       } 
                }else if(FichaContraria(new int[]{i,y+cont},this.color))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y+cont}; 
                   index=IndiceFicha(new int[]{i,y+cont});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   actual=new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y+cont},this,(this.color+1)%2,this.profundidad+1);
                       if(!actual.Jaque(color))
                       {
                         jugadas.add(actual);
                        cambioPosiciones=posiciones;  
                       } 
                }
                cont++;
            }
            cont=1;
            for(int i=x+1;i<6;i++)
            {
                if(CasillaVacia(new int[]{i,y-cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y-cont}; 
                   actual=new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y-cont},this,(this.color+1)%2,this.profundidad+1);
                       if(!actual.Jaque(color))
                       {
                         jugadas.add(actual);
                        cambioPosiciones=posiciones;  
                       } 
                }else if(FichaContraria(new int[]{i,y-cont},this.color))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y-cont}; 
                   index=IndiceFicha(new int[]{i,y-cont});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   actual=new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y-cont},this,(this.color+1)%2,this.profundidad+1);
                       if(!actual.Jaque(color))
                       {
                         jugadas.add(actual);
                        cambioPosiciones=posiciones;  
                       } 
                }
                
                if(CasillaVacia(new int[]{i,y+cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y+cont}; 
                    actual=new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y+cont},this,(this.color+1)%2,this.profundidad+1);
                       if(!actual.Jaque(color))
                       {
                         jugadas.add(actual);
                        cambioPosiciones=posiciones;  
                       }
                }else if(FichaContraria(new int[]{i,y+cont},this.color))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y+cont}; 
                   index=IndiceFicha(new int[]{i,y+cont});
                   cambioPosiciones[index]=new int[]{-1,-1};
                    actual=new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y+cont},this,(this.color+1)%2,this.profundidad+1);
                       if(!actual.Jaque(color))
                       {
                         jugadas.add(actual);
                        cambioPosiciones=posiciones;  
                       }
                }
                cont++;
            }
        }
        else if(ficha.equalsIgnoreCase("h"))
        {           
           incrementos[0][0]=incrementos[1][0]=incrementos[7][1]=incrementos[6][1]=-2;
           incrementos[7][0]=incrementos[2][0]=incrementos[0][1]=incrementos[5][1]=-1;
           incrementos[6][0]=incrementos[3][0]=incrementos[1][1]=incrementos[4][1]=1;
           incrementos[5][0]=incrementos[4][0]=incrementos[2][1]=incrementos[3][1]=2;
            int incremento[];
           for (int i = 0; i < 8; i++) {
               incremento=incrementos[i];
                if(CasillaVacia(new int[]{x+incremento[0],y+incremento[1]}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{x+incremento[0],y+incremento[1]}; 
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,x+incremento[0],y+incremento[1]},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{x+incremento[0],y+incremento[1]},this.color))
                {
                   cambioPosiciones[indiceFicha]=new int[]{x+incremento[0],y+incremento[1]}; 
                   index=IndiceFicha(new int[]{x+incremento[0],y+incremento[1]});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,x+incremento[0],y+incremento[1]},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }
            }
           
        }
        else if(ficha.equalsIgnoreCase("q"))
        {
            cont=1;
            for(int i=x-1;i>=0;i--)
            {
                if(CasillaVacia(new int[]{i,y-cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y-cont}; 
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y-cont},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{i,y-cont},this.color))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y-cont}; 
                   index=IndiceFicha(new int[]{i,y-cont});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y-cont},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }
                
                else if(CasillaVacia(new int[]{i,y+cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y+cont}; 
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y+cont},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{i,y+cont},this.color))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y+cont}; 
                   index=IndiceFicha(new int[]{i,y+cont});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y+cont},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }
                
                if(CasillaVacia(new int[]{i,y}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y}; 
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y+cont},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{i,y},this.color))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y}; 
                   index=IndiceFicha(new int[]{i,y});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }
                cont++;
            }
            cont=1;
            for(int i=x+1;i<6;i++)
            {
                if(CasillaVacia(new int[]{i,y-cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y-cont}; 
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y-cont},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{i,y-cont},this.color))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y-cont}; 
                   index=IndiceFicha(new int[]{i,y-cont});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y-cont},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }
                
                if(CasillaVacia(new int[]{i,y+cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y+cont}; 
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y+cont},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{i,y+cont},this.color))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y+cont}; 
                   index=IndiceFicha(new int[]{i,y+cont});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y+cont},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }
                
                if(CasillaVacia(new int[]{i,y}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y}; 
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{i,y},this.color))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y}; 
                   index=IndiceFicha(new int[]{i,y});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,i,y},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }
                cont++;
            }
            for(int i=y-1;i>=0;i--)
            {
             if(CasillaVacia(new int[]{x,i}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{x,i}; 
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,x,i},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{x,i},this.color))
                {
                   cambioPosiciones[indiceFicha]=new int[]{x,i}; 
                   index=IndiceFicha(new int[]{x,i});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,x,i},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }   
            }
            
            for(int i=y+1;i<6;i++)
            {
             if(CasillaVacia(new int[]{x,i}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{x,i}; 
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,x,i},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{x,i},this.color))
                {
                   cambioPosiciones[indiceFicha]=new int[]{x,i}; 
                   index=IndiceFicha(new int[]{x,i});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,x,i},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }   
            }
        }else if(ficha.equalsIgnoreCase("k"))
        {
            incrementos[0][0]=incrementos[1][0]=incrementos[7][0]=incrementos[1][1]=incrementos[2][1]=incrementos[3][1]=1;
            incrementos[2][0]=incrementos[6][0]=incrementos[0][1]=incrementos[4][1]=0;
            incrementos[3][0]=incrementos[4][0]=incrementos[5][0]=incrementos[5][1]=incrementos[6][1]=incrementos[7][1]=-1;
            int incremento[];
           for (int i = 0; i < 8; i++) {
               incremento=incrementos[i];
                if(CasillaVacia(new int[]{x+incremento[0],y+incremento[1]}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{x+incremento[0],y+incremento[1]}; 
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,x+incremento[0],y+incremento[1]},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{x+incremento[0],y+incremento[1]},this.color))
                {
                   cambioPosiciones[indiceFicha]=new int[]{x+incremento[0],y+incremento[1]}; 
                   index=IndiceFicha(new int[]{x+incremento[0],y+incremento[1]});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new int[]{indiceFicha,x+incremento[0],y+incremento[1]},this,(color+1)%2,this.profundidad+1));
                   cambioPosiciones=posiciones;
                }
            }
        }
        return jugadas;
    }
   
    
    
}
